H ?
«
‹
←
→
›
»
Language peer sets for SIMULA 67:
Norway↑
Norway/1967↑
Designed 1967 ↑
1960s languages ↑
Third generation↑
High Cold War↑
Genus Process interaction ↑
Specialised Languages ↑
Process interaction↑
Discrete↑
Simulating ↑
Process interaction/1967↑
Discrete/1967↑
Simulating/1967↑
Process interaction/Norway↑
Discrete/Norway↑
Simulating/Norway↑
Specialised Languages ↑
Specialised Languages/1967↑
Specialised Languages/no ↑
SIMULA 67(ID:301/sim053)
Object-oriented simulation language
alternate simple view
Country: Norway
Designed 1967
Published: 1967
Genus: Process interaction
Sammet category: Specialised Languages
for SImple Universal LAnguage
Generla purpose language derived from Algol and Simula 1, with influences from SIMSCRIPT
Introduced important OOP concepts like classes and objects, inheritance, and dynamic binding. The language was defined in 1967 in the "SIMULA Common Base Language". The language definition has been maintained by the SIMULA Standards Group (SSG), and the latest definition is found in the "SIMULA Standard", adopted by the SSG in 1986.
The "object-orientation" involved in SIMULA 67 pertains to the "object-system" with comprised the system which the simulation stood for, and was an extension to the (then current) notion of "problem-oriented" languages as opposed to "machine-oriented" languages.
Simula 67 works as a general-purpose language because it models all programming problems as simulations - it is modelling real-world systems every time it runs. Thus it is properly an "object-system"-oriented language, which is a move away from the ideal of an abstract algorithm being the dominating force in program design. The notion of an "object" as an entity per-se does not arrive until the biological metaphor involved in the creation of SmallTalk.
People:
Structures:
Related languages
References:
Dahl, O.-J. (1968) Dahl, O.-J. "Discrete event simulation languages" (notes from NATO school lectures) pp 349-394
in Genuys, F. (1968) Genuys, F. ed.: Programming Languages. Academic Press, London, 1968
Dahl, O.-J. and Nygaard, K. (1968) Dahl, O.-J. and Nygaard, K. "Class and subclass declarations"
in Buxton, J. (1968) Buxton, J. ed.: Simulation Programming Languages. Proceedings from the IFIP Working Conference in Oslo, May 1967, North Holland, 1968.
Dahl, O.J., Myhrhaug, B., Nygaard, K., SIMULA 67 - (1968) Dahl, O.J., Myhrhaug, B., Nygaard, K., SIMULA 67 - Common Base Language. Norwegian Computing Center Forskningveien 1B, Oslo 3, Norway (May 1968).
in Buxton, J. (1968) Buxton, J. ed.: Simulation Programming Languages. Proceedings from the IFIP Working Conference in Oslo, May 1967, North Holland, 1968.
Dahl, Ole-Johan; Myhrhaug, Bjørn; Nygaard, Kristen (1968) Dahl, Ole-Johan; Myhrhaug, Bjørn; Nygaard, Kristen "Some features of the SIMULA 67 language"
Abstract
in [Proceedings] (1968) Proceedings of the second conference on Applications of simulations, 1968, New York, New York, United States
Ichbiah, Jean D. (1971) Ichbiah, Jean D. "Extensibility in Simula 67" pp84-86
Abstract
in [ISEL 1971] (1971) [ACM] SIGPLAN Notices 6(12) December 1971 Proceedings of the international symposium on Extensible languages Grenoble, France 1971
Vaucher, Jean G. (1971) Vaucher, Jean G. "Simulation data structures using SIMULA 67" pp255-260
Abstract
in [Proceedings] (1971) The 5th Winter Simulation Conference 8-10 December 1971 Waldorf-Astoria Hotel, New York, NY
Kay, I. M. (1972) Kay, I. M. "Digital Discrete Simulation Languages. Discussion and Inventory"
Extract:
Simula and Simula 67
in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
Birtwistle, G. M. (1973) Birtwistle, G. M. "Simula - Its Features and Prospects" in "High Level Programming Languages - The Way Ahead" (National Computing Centre, 1973)
in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Ny (1973) Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Nygaard, K. "Simula begin", Studentlitteratur, Lund, Sweden, 1973.
in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Ny (1973) Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Nygaard, K. "Simula begin", Studentlitteratur, Lund, Sweden, 1973.
in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
Ichbiah and Morse (1973) Ichbiah, J.D., Morse, S.P., "General concepts of the Simula 67 Programming Language"
in Halpern, Mark I and Shaw Christopher J (eds) (1973) Halpern, Mark I and Shaw Christopher J (eds) "Annual Review in Automatic Programming" (7) 1973 Pergamon Press, Oxford
Sammet, Jean E. (1973) Sammet, Jean E. "Roster of Programming Languages for 1973" p147
in (1974) ACM Computing Reviews 15(04) April 1974
Palme, Jacob (1976) Palme, Jacob "Experience from the Standardization of the SIMULA Programming Language" pp405-409
in (1976) Software — Practice and Experience 6(03) July-September 1976
(1976) The Higher Order Language Working Group (HOLWG) Working Paper on 23 exisitng programming languages
in (1976) Software — Practice and Experience 6(03) July-September 1976
Wichmann, B. A. (1976) Wichmann, B. A. "Ackermann's function: a study in the efficiency of calling procedures" BIT 16 (1976), pp103-110
Abstract
Extract:
Introduction
Extract:
Ackermann's function
Extract:
Acknowledgements
Extract:
Results of tests (altered to include authors where known)
Extract:
Program listing
Extract:
Properties of the algorithm
Extract:
Notes on the results and Factors influencing the execution speed
Extract:
Conclusion
in (1976) Software — Practice and Experience 6(03) July-September 1976
Foster, J. (1977) Foster, J. M. and Foster, P. D. Abstract data and functors pp161-167
in [Proceedings] (1977) Proceedings of the Strathclyde ALGOL 68 conference Glasgow, Scotland 1977
Sammet, Jean E (1978) Sammet, Jean E "Roster of programming languages for 1976-77" pp56-85
in [SIGPLAN] (1978) SIGPLAN Notices 13(11) Nov 1978
Eklundh, Berth (1979) Eklundh, Berth "SIMULA-a way of thinking"
Abstract
in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
Atkins, S. M. (1980) Atkins, S. M. "A comparison of SIMULA and GPSS for simulating sparse traffic" Simulation 34, 3 (March 1980), 93- 100.
in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
Palme, Jacob (1981) Palme, Jacob "Uses of the SIMULA Process Concept" Foersvarets Forskningsanstalt, Stockholm (Sweden). Feb 81, FOA-C-10172-M6
in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
Steensgaard-Madsen, J. (1981) Steensgaard-Madsen, J. " Statement-Oriented Approach to Data Abstraction" pp1-10
Extract:
Introduction
in (1981) TOPLAS 3(1) January 1981
Kreutzer, W. (1982) Kreutzer, W. review of Palme 1982 in ACM Computing Reviews August 1982
Abstract
in (1981) TOPLAS 3(1) January 1981
Papazoglou, M P.; Georgiadis, P I.; Maritsas, D G (1984) Papazoglou, M P.; Georgiadis, P I.; Maritsas, D G. "An outline of the programming language SIMULA" pp107 - 131
in (1984) Computer Languages 9(2)
(1987) "Data Processing Programming Languages SIMULA", Swedish Standard SS 63 61 14 (1987), ISBN 91-7162-234-9, available through ANSI.
in (1984) Computer Languages 9(2)
(1987) "Et portabelt Simula-system bygget paa C." Hovedoppgave til cand.scient-graden av Sverre Johansen. Institutt for informatikk, Universitetet i Oslo, Mai 1987.
in (1984) Computer Languages 9(2)
(1987) "Object-Oriented Programming with SIMULA", Bjorn Kirkerud, A-W 1989.
Abstract
in (1984) Computer Languages 9(2)
(1989) "Viderefoering og testing av et portabelt Simula-system." Hovedoppgave til cand.scient.-graden av Terje Mjoes. Institutt for informatikk, Universitetet i Oslo, April 1989.
in (1984) Computer Languages 9(2)
J. R. Holmevik, (1994) J. R. Holmevik, "Compiling SIMULA: a historical study of technological genesis" pp25-37
in [AHC] (1994) Annals of the History of Computing 16(1) Spring 1994
George Gray (2002) George Gray "UNIVAC and ALGOL" Unisys History Newsletter
6(2) June 2002
Extract:
Information
Online copy at UNISIS History
in [AHC] (1994) Annals of the History of Computing 16(1) Spring 1994
Resources
-
Simula to C translator
-
EBNF - Syntax of SIMULA 67
1 <program> :: {<block prefix>}<block> | {<block prefix>}<compound statement> 2 <block prefix> ::= <class identifier>{(<actual paremeter list>)} 3 <block> ::= <block head>;<compound tail> 4 <block head> ::= <block head>;<declaration> | BEGIN <declaration> 5 <declaration> ::= <type declaration> | <array declaration> | <switch declaration> | <procedure declaration> | <class declaration> | <external declaration> 6 <type declaration> ::= <type><identifier list> 7 <type> ::= BOOLEAN | CHARACTER | INTEGER | REAL | REF(<class declaration>) | TEXT 8 <identifier list> ::= {<identifier list>,}<identifier> 9 <array declaration> ::= {<type>} ARRAY <array list> 10 <array list> ::={<array list>,} <array segment> 11 <array segment> ::= <identifier list>[<bound pair list>] 12 <bound pair list> ::= {<bound pair list>,}<arithmetic expression>:<arithmetic expression> 13 <switch declaration> ::= SWITCH <switch identifier> := <switch list> 14 <switch identifier> ::= <identifier> 15 <switch list> ::= {<switch list>,}<designational expression> 16 <procedure declaration> ::= {<type>} PROCEDURE <procedure heading>;<proceduere body> 17 <procedure heading> ::= <procedure identifier>{<formal parameter part>;{<mode part>;}<specification part>} 18 <formal parameter part> ::= (<identifier list>) 19 <mode part> ::= {<value part>;}<name part> | {<name part>;}<value part> 20 <value part> ::= VALUE <identifier list> 21 <name part> ::= NAME <identifier list> 22 <specification part> ::= {<specification part>;}<specifier><identifier list> 23 <specifier> ::= {<type>} ARRAY | LABEL | {<virtual part>;}<identifier list> 24 <procedure body> ::= <statement> 25 <class declaration> :: {<prefix>} CLASS <class heding>;{<virtual part>;}<class body> 26 <prefix> ::= <class identifier> 27 <class heading> ::= <class identifier>{<formal paremeter part>;{<value part>;}<specification part>} 28 <class identifier> ::= <identifier> 29 <virtual part> ::= VIRTUAL: <virtual specification part> 30 <virtual specification part> ::= {<virtual specification part>;}<virtual specifier><identifier list> 31 <virtual specifier> ::= LABEL | {<type>} PROCEDURE | SWITCH 32 <class body> ::= <split body> | <statement> 33 <split body> :: <initial part> INNER; <compound tail> 34 <initial part> ::= BEGIN | <block head>; | <initial part><statement> 35 <external declaration> ::= EXTERNAL {<type>} PROCEDURE <external list> | EXTERNAL CLASS <external list> 36 <external list> ::= {<external list>,}<external item> 37 <external item> ::= <external identifier> | <identifier> = <external identifier> 38 <compound statement> ::= BEGIN <compound tail> 39 <compound tail> ::= END | <statement>;<compound tail> 40 <statement> ::= <label list><statement> | <conditional statement> | <connection statement> | <repetition statement> | <unconditional statement> 41 <label list> ::= {<label list>}<label>: 42 <label> ::= <identifier> 43 <conditional statement> ::= <if clause><connection statement> | <if clause><repetition statement> | <if clause><unconditional statement>{ELSE <statement>} 44 <if clause> ::= IF <Boolean expression> THEN 45 <connection statement> ::= INSPECT <object expression><connection part>{OTHERWISE <statement>} 46 <connection part> ::= DO <statement> | <selective part> 47 <selective part> ::= {<selective part>} WHEN <class identifier> DO <statement> 48 <repetition statement> ::=<for statement> | <while statement> 49 <for statement> ::= FOR <variable> :- <reference list> DO <statement> | FOR <variable> := <value list> DO <statement> 50 <reference list> ::= {<reference list>,}<reference expression> {WHILE <Boolean expression>} 51 <value list> ::= {<value list>,}<value list element> 52 <value list element> ::= <value expression>{WHILE <Boolean expression>} | <arithmetic expression> STEP <arithmetic expression> UNTIL <arithmetic expression> 53 <while statement> ::= WHILE <Boolean expression> DO <statement> 54 <unconditional statement> ::= <basic statement> | {<block prefix>}<block> | {<block prefix>}<compound statement> 55 <basic statement> ::= <activation statement> | <assignment statement> | <dummy statement> | <goto statement> | <object generator> | <procedure satement> 56 <activation statement> ::=<activator><object expression>{<scheduling part>} 57 <activator> ::= ACTIVATE | REACTIVATE 58 <scheduling part> ::= AT <arithmetic expression>{PRIOR} | DELAY <arithmetic expression> {PRIOR} | BEFORE <object expression> | AFTER <object expression> 59 <assignment statement> ::= <reference assignment> | <value assignment> 60 <reference assignment> ::= <reference left part> :- <reference right part> 61 <reference left part> ::= <variable> | <procedure identifiere> 62 <reference right part> ::= <reference expression> | <reference assignment> 63 <value assignment> ::= <value left part> := <value right part> 64 <value left part> ::= <variable> | <procedure identifier> | <simple text expression> 65 <value right part> ::= <value expression> | <value assignment> 66 <dummy statement> ::= <empty> 67 <goto statement> ::= GOTO <designational expression> 68 <object generator> ::= NEW <class identifier> {(<actual parameter list>)} 69 <procedure statement> ::= {<simple reference expression>,}<procedure identifier>{(<actual parameter list>)} 70 <simple reference expression> ::= <simple object expression> | <simple text expression> 71 <actual parameter list> ::= {<actual parameter list>,}<actual parameter> 72 <actual parameter> ::= <expression> | <array identifier> | <procedure identifier> | <switch identifier> 73 <array identifier> ::= {<simple object expression>.}<identifier> 74 <procedure identifier> ::= {<simple reference expression>.}<identifier> 75 <expression> ::= <designational expression> | <reference expression> | <value expression> 76 <designational expression> ::= <simple designational expression> | <if clause> <simple designational expression> ELSE <designational expression> 77 <simple designational expression> ::= (<designational expression>) | <labal> | <switch designator> 78 <switch designator> ::= <switch identifier>[<arithmetic expression>] 79 <reference expression> ::= <object expression> | <text expression> 80 <object expression> ::= <simple object expression> | <if clause><simple object expression> ELSE <object expression> 81 <simple object expression> ::= (<object expression>) | NONE | <function designator> | <local object> | <object generator> | <qualified object> | <variable> 82 <fuction designator> ::= <procedure identifier> {(<actual parameter list>)} 83 <local object> ::= THIS <class identifier> 84 <qualified object> ::= <simple object expression> QUA <class identifier> 85 <text expression> ::= <simple text expression> | <if clause><simple text expression> ELSE <text expression> 86 <simple text expression> ::= (<text expression>) | NOTEXT | <function designator> | <variable> 87 <value expression> ::= <arithmetic expression> | <Boolean expression> | <character expression> | <text value expression> 88 <simple arithmetic expression> ::= <simple arithmetic expression> | <if clause><simple arithmetic expression> ELSE <arithmetic expression> 89 <simple arithmetic expression> ::= {{<simple arithmetic expression>}<adding operator>}<arithmetic term> 90 <adding operator> ::= + | - 91 <arithmetic term> ::= {<arithmetic term><multiplying operator>}<arithmetic factor> 92 <multiplying operator> ::= x | / | ÷ 93 <arithmetic factor> ::= {<arithmetic factor>^}<arithmetic primary> 94 <arithmetic primary> ::= (<arithmetic expression>) | <function designator> | <unsigned number> | <variable> 95 <unsigned number> ::= <decimal number> {<exponent part>} | <exponent part> 96 <decimal number> ::= <unsigned integer>{<decimal fraction>} | <decimal fraction> 97 <unsigned integer> ::= {<unsigned integer>}<digit> 98 <decimal fraction> ::= .<unsigned integer> 99 <exponent part> ::= \10{<adding operator>}<unsigned integer> 100 <Boolean expression> ::= <simple Boolean> | <if clause><simple Boolean> ELSE <Boolean expression> 101 <simple Boolean> ::= {<simple Boolean> \equ} <implication> 102 <implication> ::= {<implication> \imp}<Boolean term> 103 <Boolean term> ::= {<Boolean term> \or}<Boolean factor> 104 <Boolean factor> ::= {<Boolean factor> \and}{\not}<Boolean primary> 105 <Boolean primary> ::= (<Boolean expression>} | <logical value> | <function designator> | <relation> | <variable> 106 <logical value> ::= TRUE | FALSE 107 <relation> ::= <qualification relation> | <reference relation> | <value expression> 108 <qualification relation> ::= <simple object expression><qualification tester><class identifier> 109 <qualification tester> ::= IS | IN 110 <reference releation> ::= <object reference relation> | <text reference relation> 111 <object reference relation> ::= <simple object expression> <reference comparator><simple object expression> 112 <reference comparator> ::= == | =/= 113 <text reference relation> ::= <simple text expression><refernce comparator><simple text expression> 114 <value relation> ::= <arithmetic relation> | <character relation> | <text value relation> 115 <arithmetic relation> ::= <simple arithmetic expression><relational operator><simple arithmetic expression> 116 <relational operator> ::= < | ¾ | = | „ | > | ‚ 117 <chracter relation> ::= <simple character expression><relational operator><simple character expression> 118 <text value relation> ::= <simple text value><relational operator><simple text value> 119 <character expression> ::= <simple character expression> | <if clause><simple character expression> ELSE <character expression> 120 <simple character expression> ::= (<character expression> | <character constant> | <function designator> | <variable> 121 <character constant> ::= ′<any basic symbol>′ 122 <text value expression> ::= <simple text value> | <if clause><simple text value> ′ELSE′ <text value expression> 123 <simle text value> ::= <simple text expression> | <text constant> 124 <text constant> ::= ′<any sequence of basic symbols>′ 125 <variable> ::= <simple object expression>.<variable> | <simple variable> | <subscripted variable> 126 <simple variable> ::= <identifier> 127 <identifier ::= {<identifier>}<letter> | <identifier><digit> 128 <letter> ::= A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z 129 <digit> ::= 0|1|2|3|4|5|6|7|8|9|0 130 <subscripted variable> ::= <array identifier>[<subscript list>] 131 <subscript list> ::= {<subscript list>,}<arithmetic expression> # special signs: ÷ ... division - a line between two dots aligned verticaly (92) ^ ... power - an up-arrow (93) \10 ... power of ten - a lowered "10" (99) \equ ... logical equation - three strokes aligned verticaly (101) \imp ... logical implication - a "U" turned counter-clockwise (102) \or ... logical or - a sign like a "v" (103) \and ... logical and - like a flipped "v" (104) \not ... logical not "¬" - like a flipped and conter-clockwise turned "L" (104) ');">: Grammar
-
Ole-Johan and Kristen: some personal reminiscences "We oldies remember the good old days of the 1960's and 70's when hardly anyone gave a damn about objects. As a last aside, in 1960 I worked for one of the UK's grand old men of simulation, Tocher, for the summer. When I next saw him in 1974 I told him where I had been and he responded "Nygaard and Dahl. What's happened to them? They blazed onto the scene like comets in the early sixties, and then just vanished." Not quite, fortunately. I then tried to congratulate Tocher on using objects in the 1950's to structure his models (this he did calling them activity cycles. Tocher coded in octal not even assembler and resorted to an activity based simulation control structure). At this he blew his top and offendedly pronounced objects complete and utter rubbish."
Search in:
Google
Google scholar
World Cat
Yahoo
Overture
DBLP
Monash bib
NZ
IEEE 
ACM portal
CiteSeer
CSB
ncstrl
jstor
Bookfinder
|